package common;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;

public class _List implements UserType {

	public _List(){}

	@Override
	public Object assemble(Serializable arg0, Object arg1) throws HibernateException {
		// TODO Auto-generated method stub
		return null;
	}

    /** 
     * 自定义类型的完全复制方法,构造返回对象 
     *    1. 当nullSafeGet方法调用之后，我们获得了自定义数据对象，在向用户返回自定义数据之前 
     * deepCopy方法被调用，它将根据自定义数据对象构造一个完全拷贝，把拷贝返还给客户使用。 
     *    2.此时我们就得到了自定义数据对象的两个版本 
     *     原始版本由hibernate维护，用作脏数据检查依据，复制版本由用户使用，hibernate将在 
     * 脏数据检查过程中比较这两个版本的数据。 
     *  
     *  
     */ 
	@Override
	public Object deepCopy(Object value) throws HibernateException {
		List source=(List)value;  
        List target=new ArrayList();  
        target.addAll(source);  
        return target;  
	}

	@Override
	public Serializable disassemble(Object arg0) throws HibernateException {
		// TODO Auto-generated method stub
		return null;
	}

	/** 
     * 自定义数据类型比对方法 
     * 用作脏数据检查，X,Y为两个副本 
     */ 
	@Override
	public boolean equals(Object x, Object y) throws HibernateException {
		 if (x==y) {  
	            return true;  
	        }  
	        if(x!=null&&y!=null){  
	            List xList=(List)x;  
	            List ylList=(List)y;  
	            if (xList.size()!=ylList.size()) {  
	                return false;  
	            }  
	            for(int i=0;i<xList.size();i++){  
	                String s1=(String)xList.get(i);  
	                String s2=(String)ylList.get(i);  
	                if (!s1.equals(s2)) {  
	                    return false;  
	                }  
	            }  
	            return true;  
	        }  
	        return false;  
	}

	
	/** 
     * 返回给定类型的hashCode 
     */
	@Override
	public int hashCode(Object value) throws HibernateException {
		return value.hashCode();  
	}

	/** 
     * 表示本类型实例是否可变 
     */
	@Override
	public boolean isMutable() {
		 return false;  
	}

	/**
     * 读取数据转换为自定义类型返回
     * strings包含了自定义类型的映射字段名称
     */ 
	@Override
	public Object nullSafeGet(ResultSet resultSet, String[] strings, SessionImplementor sessionImplementor, Object owner)
			throws HibernateException, SQLException {
		 String s = (String) resultSet.getObject(strings[0]);
	        if (resultSet.wasNull()) return null;
	        if (null != s) {
	            if (s.replaceAll(" ", "").isEmpty())
	                return null;
	            return null; // new ctype(s);
	        }
	        return null;
	}

	/**
     * 数据保存时被调用
     */
	@Override
	public void nullSafeSet(PreparedStatement preparedStatement, Object o, int i, SessionImplementor sessionImplementor)
			throws HibernateException, SQLException {
		if (null == o) {
            preparedStatement.setNull(i, Types.VARCHAR);   //保存空值
        } else {
            String stringValue = String.valueOf(o);
            preparedStatement.setString(i, stringValue);
        }
	}

	@Override
	public Object replace(Object o, Object o1, Object o2)  throws HibernateException {
		return deepCopy(o);
	}

	@Override
	public Class returnedClass() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int[] sqlTypes() {
		// TODO Auto-generated method stub
		return null;
	}
    
}
